正文
第一篇文章介绍了下第一次加载网络图片的流程。
第二篇文章介绍了下加载过图片，然后重启app，从磁盘加载图片的流程。
这一篇介绍下，已经加载过图片，没有重启app，直接从内存加载图片。
我们这里说的加载图片是指同一个url的图片，不同的url就相当于第一次加载，这里就不再赘述了。
虽然说是加载同样的url的图片。但是也是分很多种情况的。这边举3个例子，来分析。
- 相同的target，也可以简单理解为相同的ImageView
- 不同的ImageView
相同的target
Glide.with(this).load("https://cdn2.jianshu.io/assets/web/nav-logo-4c7bbafe27adc892f3046e6978459bac.png").into(iv)
这里我们直接从into方法看起。
private <Y extends Target<TranscodeType>> Y into(
@NonNull Y target,
@Nullable RequestListener<TranscodeType> targetListener,
@NonNull RequestOptions options) {
...
Request request = buildRequest(target, targetListener, options);
Request previous = target.getRequest();
//由于之前第一次请求，所以当前的request!=之前的request。
//但是经过一次请求后，再次请求一样的url
if (request.isEquivalentTo(previous)
&& !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
request.recycle();
if (!Preconditions.checkNotNull(previous).isRunning()) {
previous.begin();
}
return target;
}
requestManager.clear(target);
target.setRequest(request);
requestManager.track(target, request);
return target;
}
之前第一次请求的时候，判断条件不成立，直接走requestManager.track(target, request);，而现在相同的target请求一样的url，这里会再次构建一个新的Request对象。而target也保存着之前请求过的Request对象。
//SingleRequest.java
@Override
public boolean isEquivalentTo(Request o) {
if (o instanceof SingleRequest) {
SingleRequest<?> that = (SingleRequest<?>) o;
return overrideWidth == that.overrideWidth
&& overrideHeight == that.overrideHeight
&& Util.bothModelsNullEquivalentOrEquals(model, that.model)
&& transcodeClass.equals(that.transcodeClass)
&& requestOptions.equals(that.requestOptions)
&& priority == that.priority
&& listenerCountEquals(this, that);
}
return false;
}
这里的Request对象其实是SingleRequest这里就不多介绍了。第二次请求，参数肯定还是跟第一次请求一致，所以返回true。当然这里还有个判断。
private boolean isSkipMemoryCacheWithCompletePreviousRequest(
RequestOptions options, Request previous) {
return !options.isMemoryCacheable() && previous.isComplete();
}
看options中是否设置不支持内存缓存以及之前的请求是否以及完成。
所以第二次相同的target加载图片的话，会进入if里面
request.recycle();
if (!Preconditions.checkNotNull(previous).isRunning()) {
previous.begin();
}
return target;
}
把这一次生成的request对象回收后，开始请求之前的request
//SingleRequest.java
public void begin() {
...
if (status == Status.COMPLETE) {
onResourceReady(resource, DataSource.MEMORY_CACHE);
return;
}
....
}
因为之前这个Request已经请求过了，所以参数status==Status.COMPLETE。所以直接调用onResourceReady，没有发起真正的请求。使用了之前缓存的。
不同的target
我们还是从前面的into方法开始，显然不同的target肯定不会进if语句里面了。还是走requestManager.track(target, request)。
这里让大家更清楚点，就再完整的过一遍.
//RequestManager.java
void track(@NonNull Target<?> target, @NonNull Request request) {
...
requestTracker.runRequest(request);
}
//RequestTracker.java
public void runRequest(@NonNull Request request) {
...
request.begin();
...
}
//SingleRequest.java
public void begin() {
....
target.getSize(this);
...
}
//ViewTarget.java
public void getSize(@NonNull SizeReadyCallback cb) {
sizeDeterminer.getSize(cb);
}
//ViewTarget.java
void getSize(@NonNull SizeReadyCallback cb) {
...
ViewTreeObserver observer = view.getViewTreeObserver();
layoutListener = new SizeDeterminerLayoutListener(this);
observer.addOnPreDrawListener(layoutListener);
...
}
//SingleRequest.java
public void onSizeReady(int width, int height) {
...
loadStatus = engine.load(...);
...
}
//Engine.java
public <R> LoadStatus load(
...
EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
resourceClass, transcodeClass, options);
EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
if (active != null) {
cb.onResourceReady(active, DataSource.MEMORY_CACHE);
...
return null;
}
EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
if (cached != null) {
cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
if (VERBOSE_IS_LOGGABLE) {
logWithTimeAndKey("Loaded resource from cache", startTime, key);
}
return null;
}
...
}
这里就直接把源码贴出，给大家过一遍，就不一步步解析了，不太熟悉的同学可以看下第一篇文章。那么这边就直接说出结果
EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
if (active != null) {
cb.onResourceReady(active, DataSource.MEMORY_CACHE);
...
return null;
}
private EngineResource<?> loadFromActiveResources(Key key, boolean isMemoryCacheable) {
...
EngineResource<?> active = activeResources.get(key);
...
return active;
}
其实就是直接从activeResources获取到缓存的资源直接调用onResourceReady方法。
那么我们这里可以回溯下，activeResources是什么时候放入资源的呢。ctrl+鼠标左键看下引用。
找到了2个地方，第一个地方很快就排除了。只剩下这一个，来看
//Engine.java
public void onEngineJobComplete(EngineJob<?> engineJob, Key key, EngineResource<?> resource) {
...
if (resource.isCacheable()) {
activeResources.activate(key, resource);
}
}
...
}
继续找哪里调用onEngineJobComplete，也只有2个地方，有个地方没有传入resource引用直接排除。
//EngineJob.java
void handleResultOnMainThread() {
...
listener.onEngineJobComplete(this, key, engineResource);
...
}
public boolean handleMessage(Message message) {
EngineJob<?> job = (EngineJob<?>) message.obj;
switch (message.what) {
case MSG_COMPLETE:
job.handleResultOnMainThread();
...
看到这个MSG_COMPLETE 大家应该很熟悉，可以去看下第一篇文章，最终加载好图片之后，发送下这个消息。然后图片就缓存再内存里了。
