Android图片加载框架解析之Glide的自定义模块功能讲解
自定义模块的基本用法
学到这里相信你已经知道，glide的用法是非常非常简单的，大多数情况下，我们想要实现的图片加载效果只需要一行代码就能解决了。但是glide过于简洁的api也造成了一个问题，就是如果我们想要更改glide的某些默认配置项应该怎么操作呢？很难想象如何将更改glide配置项的操作串联到一行经典的glide图片加载语句中当中吧？没错，这个时候就需要用到自定义模块功能了。
自定义模块功能可以将更改glide配置，替换glide等操作独立出来，使得我们能轻松地对glide的各种配置进行自定义，并且又和glide的图片加载逻辑没有任何交集，这也是一种低耦合方式的体现。那么接下来我们就学习一下自定义模块的基本用法。
首先需要定义一个我们自己的模块类，并让它实现glidemodule接口，如下所示：
public class myglidemodule implements glidemodule {
@override
public void applyoptions(context context, glidebuilder builder) {
}
@override
public void registercomponents(context context, glide glide) {
}
}
1 2 3 4 5 6 7 8 9 10
可以看到，在myglidemodule类当中，我们重写了applyoptions()和registercomponents()方法，这两个方法分别就是用来更改glide和配置以及替换glide组件的。我们待会儿只需要在这两个方法中加入具体的逻辑，就能实现更改glide配置或者替换glide组件的功能了。
不过，目前glide还无法识别我们自定义的myglidemodule，如果想要让它生效，还得在androidmanifest.xml文件当中加入如下配置才行：
... ...
在
这样的话，我们就将glide自定义模块的功能完成了，是不是非常简单？现在glide已经能够识别我们自定义的这个myglidemodule了，但是在编写具体的功能之前，我们还是按照老规矩一下，从源码的层面上来分析一下，glide到底是如何识别出这个自定义的myglidemodule的。
自定义模块的原理
这里我不会带着大家从glide代码执行的第一步一行行重头去解析glide的源码，而是只分析和自定义模块相关的部分。如果你想将glide的源码通读一遍的话，可以去看本系列的第二篇文章android图片加载框架最全解析（二），从源码的角度理解glide的执行流程。
显然我们已经用惯了glide.with(context).load(url).into(imageview)这样一行简洁的glide图片加载语句，但是我们好像从来没有注意过glide这个类本身的实例。然而事实上，glide类确实是有创建实例的，只不过是在内部由glide自动帮我们创建和管理了，对于开发者而言，大多数情况下是不用关心它的，只需要调用它的静态方法就可以了。
那么glide的实例到底是在哪里创建的呢？我们来看下glide类中的get()方法的源码，如下所示：
public class glide {
private static volatile glide glide;
...
public static glide get(context context) {
if (glide == null) {
synchronized (glide.class) {
if (glide == null) {
context applicationcontext = context.getapplicationcontext();
list modules = new manifestparser(applicationcontext).parse();
glidebuilder builder = new glidebuilder(applicationcontext);
for (glidemodule module : modules) {
module.applyoptions(applicationcontext, builder);
}
glide = builder.createglide();
for (glidemodule module : modules) {
module.registercomponents(applicationcontext, glide);
}
}
}
}
return glide;
}
...
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
我们来仔细看一下上面这段代码。首先这里使用了一个单例模式来获取glide对象的实例，可以看到，这是一个非常典型的双重锁模式。然后在第12行，调用manifestparser的parse()方法去解析androidmanifest.xml文件中的配置，实际上就是将androidmanifest中所有值为glidemodule的meta-data配置读取出来，并将相应的自定义模块实例化。由于你可以自定义任意多个模块，因此这里我们将会得到一个glidemodule的list集合。
接下来在第13行创建了一个glidebuilder对象，并通过一个循环调用了每一个glidemodule的applyoptions()方法，同时也把glidebuilder对象作为参数传入到这个方法中。而applyoptions()方法就是我们可以加入自己的逻辑的地方了，虽然目前为止我们还没有编写任何逻辑。
再往下的一步就非常关键了，这里调用了glidebuilder的createglide()方法，并返回了一个glide对象。也就是说，glide对象的实例就是在这里创建的了，那么我们跟到这个方法当中瞧一瞧：
public class glidebuilder {
private final context context;
private engine engine;
private bitmappool bitmappool;
private memorycache memorycache;
private executorservice sourceservice;
private executorservice diskcacheservice;
private decodeformat decodeformat;
private diskcache.factory diskcachefactory;
...
glide createglide() {
if (sourceservice == null) {
final int cores = math.max(1, runtime.getruntime().availableprocessors());
sourceservice = new fifoprioritythreadpoolexecutor(cores);
}
if (diskcacheservice == null) {
diskcacheservice = new fifoprioritythreadpoolexecutor(1);
}
memorysizecalculator calculator = new memorysizecalculator(context);
if (bitmappool == null) {
if (build.version.sdk_int >= build.version_codes.honeycomb) {
int size = calculator.getbitmappoolsize();
bitmappool = new lrubitmappool(size);
} else {
bitmappool = new bitmappooladapter();
}
}
if (memorycache == null) {
memorycache = new lruresourcecache(calculator.getmemorycachesize());
}
if (diskcachefactory == null) {
diskcachefactory = new internalcachediskcachefactory(context);
}
if (engine == null) {
engine = new engine(memorycache, diskcachefactory, diskcacheservice, sourceservice);
}
if (decodeformat == null) {
decodeformat = decodeformat.default;
}
return new glide(engine, memorycache, bitmappool, context, decodeformat);
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
这个方法中会创建bitmappool、memorycache、diskcache、decodeformat等对象的实例，并在最后一行创建一个glide对象的实例，然后将前面创建的这些实例传入到glide对象当中，以供后续的图片加载操作使用。
但是大家有没有注意到一个细节，createglide()方法中创建任何对象的时候都做了一个空检查，只有在对象为空的时候才会去创建它的实例。也就是说，如果我们可以在applyoptions()方法中提前就给这些对象初始化并赋值，那么在createglide()方法中就不会再去重新创建它们的实例了，从而也就实现了更改glide配置的功能。关于这个功能我们待会儿会进行具体的演示。
现在继续回到glide的get()方法中，得到了glide对象的实例之后，接下来又通过一个循环调用了每一个glidemodule的registercomponents()方法，在这里我们可以加入替换glide的组件的逻辑。
好了，这就是glide自定义模块的全部工作原理。了解了它的工作原理之后，接下来所有的问题就集中在我们到底如何在applyoptions()和registercomponents()这两个方法中加入具体的逻辑了，下面我们马上就来学习一下。
更改glide配置
刚才在分析自定义模式工作原理的时候其实就已经提到了，如果想要更改glide的默认配置，其实只需要在applyoptions()方法中提前将glide的配置项进行初始化就可以了。那么glide一共有哪些配置项呢？这里我给大家做了一个列举：
setmemorycache()
用于配置glide的内存缓存策略，默认配置是lruresourcecache。
setbitmappool()
用于配置glide的bitmap缓存池，默认配置是lrubitmappool。
setdiskcache()
用于配置glide的硬盘缓存策略，默认配置是internalcachediskcachefactory。
setdiskcacheservice()
用于配置glide读取缓存中图片的异步执行器，默认配置是fifoprioritythreadpoolexecutor，也就是先入先出原则。
setresizeservice()
用于配置glide读取非缓存中图片的异步执行器，默认配置也是fifoprioritythreadpoolexecutor。
setdecodeformat()
用于配置glide加载图片的解码模式，默认配置是rgb_565。
其实glide的这些默认配置都非常科学且合理，使用的缓存算法也都是效率极高的，因此在绝大多数情况下我们并不需要去修改这些默认配置，这也是glide用法能如此简洁的一个原因。
但是glide科学的默认配置并不影响我们去学习自定义glide模块的功能，因此总有某些情况下，默认的配置可能将无法满足你，这个时候就需要我们自己动手来修改默认配置了。
下面就通过具体的实例来看一下吧。刚才说到，glide默认的硬盘缓存策略使用的是internalcachediskcachefactory，这种缓存会将所有glide加载的图片都存储到当前应用的私有目录下。这是一种非常安全的做法，但同时这种做法也造成了一些不便，因为私有目录下即使是开发者自己也是无法查看的，如果我想要去验证一下图片到底有没有成功缓存下来，这就有点不太好办了。
这种情况下，就非常适合使用自定义模块来更改glide的默认配置。我们完全可以自己去实现diskcache.factory接口来自定义一个硬盘缓存策略，不过却大大没有必要这么做，因为glide本身就内置了一个externalcachediskcachefactory，可以允许将加载的图片都缓存到sd卡。
那么接下来，我们就尝试使用这个externalcachediskcachefactory来替换默认的internalcachediskcachefactory，从而将所有glide加载的图片都缓存到sd卡上。
由于在前面我们已经创建好了一个自定义模块myglidemodule，那么现在就可以直接在这里编写逻辑了，代码如下所示：
public class myglidemodule implements glidemodule {
@override
public void applyoptions(context context, glidebuilder builder) {
builder.setdiskcache(new externalcachediskcachefactory(context));
}
@override
public void registercomponents(context context, glide glide) {
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13
没错，就是这么简单，现在所有glide加载的图片都会缓存到sd卡上了。
另外，internalcachediskcachefactory和externalcachediskcachefactory的默认硬盘缓存大小都是250m。也就是说，如果你的应用缓存的图片总大小超出了250m，那么glide就会按照disklrucache算法的原则来清理缓存的图片。
当然，我们是可以对这个默认的缓存大小进行修改的，而且修改方式非常简单，如下所示：
public class myglidemodule implements glidemodule {
public static final int disk_cache_size = 500 * 1024 * 1024;
@override
public void applyoptions(context context, glidebuilder builder) {
builder.setdiskcache(new externalcachediskcachefactory(context, disk_cache_size));
}
@override
public void registercomponents(context context, glide glide) {
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
只需要向externalcachediskcachefactory或者internalcachediskcachefactory再传入一个参数就可以了，现在我们就将glide硬盘缓存的大小调整成了500m。
好了，更改glide配置的功能就是这么简单，那么接下来我们就来验证一下更改的配置到底有没有生效吧。
这里还是使用最基本的glide加载语句来去加载一张网络图片：
string url = "http://guolin.tech/book.png"; glide.with(this) .load(url) .into(imageview);1 2 3 4
运行一下程序，效果如下图所示：
ok，现在图片已经加载出现了，那么我们去找一找它的缓存吧。
externalcachediskcachefactory的默认缓存路径是在sdcard/android/包名/cache/image_manager_disk_cache目录当中，我们使用文件进入到这个目录，结果如下图所示。
可以看到，这里有两个文件，其中journal文件是disklrucache算法的日志文件，这个文件必不可少，且只会有一个。想了解更多关于disklrucache算法的朋友，可以去阅读我的这篇博客android disklrucache完全解析，硬盘缓存的最佳方案。
而另外一个文件就是那张缓存的图片了，它的文件名虽然看上去很奇怪，但是我们只需要把这个文件的后缀改成.png，然后用图片浏览器打开，结果就一目了然了，如下图所示。
由此证明，我们已经成功将glide的硬盘缓存路径修改到sd卡上了。
另外这里再提一点，我们都知道glide和picasso的用法是非常相似的，但是有一点差别却很大。glide加载图片的默认格式是rgb_565，而picasso加载图片的默认格式是argb_8888。argb_8888格式的图片效果会更加细腻，但是内存开销会比较大。而rgb_565格式的图片则更加节省内存，但是图片效果上会差一些。
glide和picasso各自采取的默认图片格式谈不上熟优熟劣，只能说各自的取舍不一样。但是如果你希望glide也能使用argb_8888的图片格式，这当然也是可以的。我们只需要在myglidemodule中更改一下默认配置即可，如下所示：
public class myglidemodule implements glidemodule {
public static final int disk_cache_size = 500 * 1024 * 1024;
@override
public void applyoptions(context context, glidebuilder builder) {
builder.setdiskcache(new externalcachediskcachefactory(context, disk_cache_size));
builder.setdecodeformat(decodeformat.prefer_argb_8888);
}
@override
public void registercomponents(context context, glide glide) {
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
通过这样配置之后，使用glide加载的所有图片都将会使用argb_8888的格式，虽然图片质量变好了，但同时内存开销也会明显增大，所以你要做好心理准备哦。
好了，关于更改glide配置的内容就介绍这么多，接下来就让我们进入到下一个非常重要的主题，替换glide组件。
替换glide组件
替换glide组件功能需要在自定义模块的registercomponents()方法中加入具体的替换逻辑。相比于更改glide配置，替换glide组件这个功能的难度就明显大了不少。glide中的组件非常繁多，也非常复杂，但其实大多数情况下并不需要我们去做什么替换。不过，有一个组件却有着比较大的替换需求，那就是glide的http通讯组件。
默认情况下，glide使用的是基于原生httpurlconnection进行订制的http通讯组件，但是现在大多数的android开发者都更喜欢使用okhttp，因此将glide中的http通讯组件修改成okhttp的这个需求比较常见，那么今天我们也会以这个功能来作为例子进行讲解。
首先来看一下glide中目前有哪些组件吧，在glide类的构造方法当中，如下所示：
public class glide {
glide(engine engine, memorycache memorycache, bitmappool bitmappool, context context, decodeformat decodeformat) {
...
register(file.class, parcelfiledescriptor.class, new filedescriptorfileloader.factory());
register(file.class, inputstream.class, new streamfileloader.factory());
register(int.class, parcelfiledescriptor.class, new filedescriptorresourceloader.factory());
register(int.class, inputstream.class, new streamresourceloader.factory());
register(integer.class, parcelfiledescriptor.class, new filedescriptorresourceloader.factory());
register(integer.class, inputstream.class, new streamresourceloader.factory());
register(string.class, parcelfiledescriptor.class, new filedescriptorstringloader.factory());
register(string.class, inputstream.class, new streamstringloader.factory());
register(uri.class, parcelfiledescriptor.class, new filedescriptoruriloader.factory());
register(uri.class, inputstream.class, new streamuriloader.factory());
register(url.class, inputstream.class, new streamurlloader.factory());
register(glideurl.class, inputstream.class, new httpurlglideurlloader.factory());
register(byte[].class, inputstream.class, new streambytearrayloader.factory());
...
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
可以看到，这里都是以调用register()方法的方式来注册一个组件，register()方法中传入的参数表示glide支持使用哪种参数类型来加载图片，以及如何去处理这种类型的图片加载。举个例子：
register(glideurl.class, inputstream.class, new httpurlglideurlloader.factory());1
这句代码就表示，我们可以使用glide.with(context).load(new glideurl("url...")).into(imageview)的方式来加载图片，而httpurlglideurlloader.factory则是要负责处理具体的网络通讯逻辑。如果我们想要将glide的http通讯组件替换成okhttp的话，那么只需要在自定义模块当中重新注册一个glideurl类型的组件就行了。
说到这里有的朋友可能会疑问了，我们平时使用glide加载图片时，大多数情况下都是直接将图片的url字符串传入到load()方法当中的，很少会将它封装成glideurl对象之后再传入到load()方法当中，那为什么只需要重新注册一个glideurl类型的组件，而不需要去重新注册一个string类型的组件呢？其实道理很简单，因为load(string)方法只是glide给我们提供一种简易的api封装而已，它的底层仍然还是调用的glideurl组件，因此我们在替换组件的时候只需要直接替换最底层的，这样就一步到位了。
那么接下来我们就开始学习到底如何将glide的http通讯组件替换成okhttp。
首先第一步，不用多说，肯定是要先将okhttp的库引入到当前项目中，如下所示：
dependencies {
compile 'com.squareup.okhttp3:okhttp:3.9.0'
}
1 2 3
然后接下来该怎么做呢？我们只要依葫芦画瓢就可以了。刚才不是说glide的网络通讯逻辑是由httpurlglideurlloader.factory来负责的吗，那么我们就来看一下它的源码：
public class httpurlglideurlloader implements modelloader {
private final modelcache modelcache;
public static class factory implements modelloaderfactory {
private final modelcache modelcache = new modelcache(500);
@override
public modelloader build(context context, genericloaderfactory factories) {
return new httpurlglideurlloader(modelcache);
}
@override
public void teardown() {
}
}
public httpurlglideurlloader() {
this(null);
}
public httpurlglideurlloader(modelcache modelcache) {
this.modelcache = modelcache;
}
@override
public datafetcher getresourcefetcher(glideurl model, int width, int height) {
glideurl url = model;
if (modelcache != null) {
url = modelcache.get(model, 0, 0);
if (url == null) {
modelcache.put(model, 0, 0, model);
url = model;
}
}
return new httpurlfetcher(url);
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
可以看到，httpurlglideurlloader.factory是一个内部类，外层的httpurlglideurlloader类实现了modelloader
public class httpurlfetcher implements datafetcher {
private static final string tag = "httpurlfetcher";
private static final int maximum_redirects = 5;
private static final httpurlconnectionfactory default_connection_factory = new defaulthttpurlconnectionfactory();
private final glideurl glideurl;
private final httpurlconnectionfactory connectionfactory;
private httpurlconnection urlconnection;
private inputstream stream;
private volatile boolean iscancelled;
public httpurlfetcher(glideurl glideurl) {
this(glideurl, default_connection_factory);
}
httpurlfetcher(glideurl glideurl, httpurlconnectionfactory connectionfactory) {
this.glideurl = glideurl;
this.connectionfactory = connectionfactory;
}
@override
public inputstream loaddata(priority priority) throws exception {
return loaddatawithredirects(glideurl.tourl(), 0 , null , glideurl.getheaders());
}
private inputstream loaddatawithredirects(url url, int redirects, url lasturl, map headers)
throws ioexception {
if (redirects >= maximum_redirects) {
throw new ioexception("too many (> " + maximum_redirects + ") redirects!");
} else {
try {
if (lasturl != null && url.touri().equals(lasturl.touri())) {
throw new ioexception("in re-direct loop");
}
} catch (urisyntaxexception e) {
}
}
urlconnection = connectionfactory.build(url);
for (map.entry headerentry : headers.entryset()) {
urlconnection.addrequestproperty(headerentry.getkey(), headerentry.getvalue());
}
urlconnection.setconnecttimeout(2500);
urlconnection.setreadtimeout(2500);
urlconnection.setusecaches(false);
urlconnection.connect();
if (iscancelled) {
return null;
}
final int statuscode = urlconnection.getresponsecode();
if (statuscode / 100 == 2) {
return getstreamforsuccessfulrequest(urlconnection);
} else if (statuscode / 100 == 3) {
string redirecturlstring = urlconnection.getheaderfield("location");
if (textutils.isempty(redirecturlstring)) {
throw new ioexception("received empty or null redirect url");
}
url redirecturl = new url(url, redirecturlstring);
return loaddatawithredirects(redirecturl, redirects + 1, url, headers);
} else {
if (statuscode == -1) {
throw new ioexception("unable to retrieve response code from httpurlconnection.");
}
throw new ioexception("request failed " + statuscode + ": " + urlconnection.getresponsemessage());
}
}
private inputstream getstreamforsuccessfulrequest(httpurlconnection urlconnection)
throws ioexception {
if (textutils.isempty(urlconnection.getcontentencoding())) {
int contentlength = urlconnection.getcontentlength();
stream = contentlengthinputstream.obtain(urlconnection.getinputstream(), contentlength);
} else {
stream = urlconnection.getinputstream();
}
return stream;
}
@override
public void cleanup() {
if (stream != null) {
try {
stream.close();
} catch (ioexception e) {
}
}
if (urlconnection != null) {
urlconnection.disconnect();
}
}
@override
public string getid() {
return glideurl.getcachekey();
}
@override
public void cancel() {
iscancelled = true;
}
interface httpurlconnectionfactory {
httpurlconnection build(url url) throws ioexception;
}
private static class defaulthttpurlconnectionfactory implements httpurlconnectionfactory {
@override
public httpurlconnection build(url url) throws ioexception {
return (httpurlconnection) url.openconnection();
}
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
上面这段代码看上去应该不费力吧？其实就是一些httpurlconnection的用法而已。那么我们只需要仿照着httpurlfetcher的代码来写，并且把http的通讯组件替换成okhttp就可以了。
现在新建一个okhttpfetcher类，并且同样实现datafetcher
public class okhttpfetcher implements datafetcher {
private final okhttpclient client;
private final glideurl url;
private inputstream stream;
private responsebody responsebody;
private volatile boolean iscancelled;
public okhttpfetcher(okhttpclient client, glideurl url) {
this.client = client;
this.url = url;
}
@override
public inputstream loaddata(priority priority) throws exception {
request.builder requestbuilder = new request.builder()
.url(url.tostringurl());
for (map.entry headerentry : url.getheaders().entryset()) {
string key = headerentry.getkey();
requestbuilder.addheader(key, headerentry.getvalue());
}
requestbuilder.addheader("httplib", "okhttp");
request request = requestbuilder.build();
if (iscancelled) {
return null;
}
response response = client.newcall(request).execute();
responsebody = response.body();
if (!response.issuccessful() || responsebody == null) {
throw new ioexception("request failed with code: " + response.code());
}
stream = contentlengthinputstream.obtain(responsebody.bytestream(),
responsebody.contentlength());
return stream;
}
@override
public void cleanup() {
try {
if (stream != null) {
stream.close();
}
if (responsebody != null) {
responsebody.close();
}
} catch (ioexception e) {
e.printstacktrace();
}
}
@override
public string getid() {
return url.getcachekey();
}
@override
public void cancel() {
iscancelled = true;
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
上面这段代码完全就是我照着httpurlfetcher依葫芦画瓢写出来的，用的也都是一些okhttp的基本用法，相信不需要再做什么解释了吧。可以看到，使用okhttp来编写网络通讯的代码要比使用httpurlconnection简单很多，代码行数也少了很多。注意在第22行，我添加了一个httplib: okhttp的请求头，这个是待会儿我们用来进行测试验证的，大家实际项目中的代码无须添加这个请求头。
那么我们就继续发挥依葫芦画瓢的精神，仿照着httpurlglideurlloader再写一个okhttpglideurlloader吧。新建一个okhttpglideurlloader类，并且实现modelloader
public class okhttpglideurlloader implements modelloader {
private okhttpclient okhttpclient;
public static class factory implements modelloaderfactory {
private okhttpclient client;
public factory() {
}
public factory(okhttpclient client) {
this.client = client;
}
private synchronized okhttpclient getokhttpclient() {
if (client == null) {
client = new okhttpclient();
}
return client;
}
@override
public modelloader build(context context, genericloaderfactory factories) {
return new okhttpglideurlloader(getokhttpclient());
}
@override
public void teardown() {
}
}
public okhttpglideurlloader(okhttpclient client) {
this.okhttpclient = client;
}
@override
public datafetcher getresourcefetcher(glideurl model, int width, int height) {
return new okhttpfetcher(okhttpclient, model);
}
}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
注意这里的factory我提供了两个构造方法，一个是不带任何参数的，一个是带okhttpclient参数的。如果对okhttp不需要进行任何自定义的配置，那么就调用无参的factory构造函数即可，这样会在内部自动创建一个okhttpclient实例。但如果你需要想添加拦截器，或者修改okhttp的默认超时等等配置，那么就自己创建一个okhttpclient的实例，然后传入到factory的构造方法当中就行了。
好了，现在就只差最后一步，将我们刚刚创建的okhttpglideurlloader和okhttpfetcher注册到glide当中，将原来的http通讯组件给替换掉，如下所示：
public class myglidemodule implements glidemodule {
...
@override
public void registercomponents(context context, glide glide) {
glide.register(glideurl.class, inputstream.class, new okhttpglideurlloader.factory());
}
}
1 2 3 4 5 6 7 8 9 10
可以看到，这里也是调用了glide的register()方法来注册组件的。register()方法中使用的map类型来存储已注册的组件，因此我们这里重新注册了一遍glideurl.class类型的组件，就把原来的组件给替换掉了。
理论上来说，现在我们已经成功将glide的http通讯组件替换成okhttp了，现在唯一的问题就是我们该如何去验证一下到底有没有替换成功呢？
验证的方式我倒是想了很多种，比如添加okhttp拦截器，或者自己架设一个测试用的服务器都是可以的。不过为了让大家最直接地看到验证结果，这里我准备使用fiddler这个抓包工具来进行验证。这个工具的用法非常简单，但是限于篇幅我就不在本篇文章中介绍这个工具的用法了，还没用过这个工具的朋友们可以通过这篇文章了解一下。
在开始验证之前，我们还得要再修改一下glide加载图片的代码才行，如下所示：
string url = "http://guolin.tech/book.png"; glide.with(this) .load(url) .skipmemorycache(true) .diskcachestrategy(diskcachestrategy.none) .into(imageview);1 2 3 4 5 6
这里我把glide的内存缓存和硬盘缓存都禁用掉了，不然的话，glide可能会直接读取刚才缓存的图片，而不会再重新发起网终请求。
好的，现在我们重新使用glide加载一下图片，然后观察fiddler中的抓包情况，如下图所示。
可以看到，在http请求头中确实有我们刚才自己添加的httplib: okhttp。也就说明，glide的http通讯组件的确被替换成功了。
更简单的组件替换
上述方法是我们纯手工地将glide的http通讯组件进行了替换，如果你不想这么麻烦也是可以的，glide官方给我们提供了非常简便的http组件替换方式。并且除了支持okhttp3之外，还支持okhttp2和volley。
我们只需要在gradle当中添加几行库的配置就行了。比如使用okhttp3来作为http通讯组件的配置如下：
dependencies {
compile 'com.squareup.okhttp3:okhttp:3.9.0'
compile 'com.github.bumptech.glide:okhttp3-integration:1.5.0@aar'
}
1 2 3 4
使用okhttp2来作为http通讯组件的配置如下：
dependencies {
compile 'com.github.bumptech.glide:okhttp-integration:1.5.0@aar'
compile 'com.squareup.okhttp:okhttp:2.7.5'
}
1 2 3 4
使用volley来作为http通讯组件的配置如下：
dependencies {
compile 'com.github.bumptech.glide:volley-integration:1.5.0@aar'
compile 'com.mcxiaoke.volley:library:1.0.19'
}
1 2 3 4
当然了，这些库背后的工作原理和我们刚才自己手动实现替换http组件的原理是一模一样的。而学会了手动替换组件的原理我们就能更加轻松地扩展更多丰富的功能，因此掌握这一技能还是非常重要的。