小菜读Glide3.0源码----into()

我进尽量不打错别字，用词准确，不造成阅读障碍。

本文基于Glide3.7.0源码，并不是4.0系列。本系列分为三部分：with(…)、load(…)、into(…)；本篇文章只介绍into(…)这一个步骤，前两个步骤相对而言比较简单，特别是with(…)，而into(…)内容非常复杂，必须单独开一篇，要不然太长了。关于with(…)和load(…)的文章在这里小菜读Glide3.0 源码----with()和load()， 本文的主要目的在于学习总结，并给需要的人一点帮助，并不奢望多么完美，如有错误，欢迎指出。

一.准备

我们使用最简单的例子:

Glide.with(this).load("字符串地址").into(imageView);  //this为Activity

我们分析的是最简单的情况，再复杂一点的我就不能保证正确了，哭~~！

Glide源码阅读3+3+3(我自己整理的)中这是第一个"3"中最后一步，也包含了最后一个"3"中的全部。

二.into()

我们还记得load()方法最后返回的是DrawableTypeRequest对象，而这个对象是没有into()方法的，但是它继承了DrawableRequestBuilder类，这个类中是有into()方法的，所以我们看看DrawableRequestBuilder中的into()方法。

//DrawableRequestBuilder.class
public Target<GlideDrawable> into(ImageView view) {
        return super.into(view);
}

很简单的调用父类into()方法，返回一个Target，默认是GlideDrawable类型，Target只是有个接口，所以就要返回实现了这个接口的类的对象，往后面看，就知道这个Target是什么了。其父类为GenericRequestBuilder，看名字也看出来这两者是有关系的。

//GenericRequestBuilder.class
public Target<TranscodeType> into(ImageView view) {
        Util.assertMainThread();
        if (view == null) {
            throw new IllegalArgumentException("You must pass in a non null View");
        } else {
            if (!this.isTransformationSet && view.getScaleType() != null) {
                switch(view.getScaleType()) {
                case CENTER_CROP:
                    this.applyCenterCrop();
                    break;
                case FIT_CENTER:
                case FIT_START:
                case FIT_END:
                    this.applyFitCenter();
                }
            }
            return this.into(this.glide.buildImageViewTarget(view, this.transcodeClass));
        }
    }

​ 嗯，返回一个Target对象，TranscodeType是什么？翻译过来是转码类型，是在类构造方法里面被设置的，默认是GlideDrawable，这个不讲太多，后面就明白了。

​ 首先是确保运行在主线程，如果不是，就直接抛异常：throw new IllegalArgumentException(“You must call this method on the main thread”); 然后是判断view是否为null，是则抛异常，不是则继续，判断有没有设置填充方式，我们知道ImageView是有填充方式的，不同的填充方式效果差很远，计算的东西也不一样，这里是Glide代码细研究的地方，暂且不论，看后面，this.into(this.glide.buildImageViewTarget(view, this.transcodeClass));。 先看this.glide.buildImageViewTarget(view,this.transcodeClass);看名字是build一个Target，参数view不必说，transcodeClass就是默认的GlideDrawable.Class，上一篇文章讲过了，Glide这个类在构造方法里面注册了超多的Factory，其中就有imageViewTargetFactory，所以这个build…Target(…)其实是调用ImageViewFactory的buildTarget(…)方法：

//ImageViewTargetFactory.class
public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {
        if (GlideDrawable.class.isAssignableFrom(clazz)) {
            return new GlideDrawableImageViewTarget(view);
        } else if (Bitmap.class.equals(clazz)) {
            return new BitmapImageViewTarget(view);
        } else if (Drawable.class.isAssignableFrom(clazz)) {
            return new DrawableImageViewTarget(view);
        } else {
            throw new IllegalArgumentException("Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
        }
    }

所以说默认是GlideDrawableImageViewTarget。其它的,看名字还有一个Bitmap，这个你要指定Bitmap才可以，至于DrawableImageViewTarget，一般用不到。target翻译过来是目标的意思，也就是说我们传进来的imageView，被我们包装成了target，也就是我们的目标，为什么要这样，往后面看。

回到这里：

return this.into(this.glide.buildImageViewTarget(view, this.transcodeClass));

Target搞定了，又调用了另一个into(…)：

//GenericRequestBuilder.class
public <Y extends Target<TranscodeType>> Y into(Y target) {
        Util.assertMainThread();
        if (target == null) {
            throw new IllegalArgumentException("You must pass in a non null Target");
        } else if (!this.isModelSet) {
            throw new IllegalArgumentException("You must first set a model (try #load())");
        } else {
            Request previous = target.getRequest();
            if (previous != null) {
                previous.clear();
                this.requestTracker.removeRequest(previous);
                previous.recycle();
            }

            Request request = this.buildRequest(target);
            target.setRequest(request);
            this.lifecycle.addListener(target);
            this.requestTracker.runRequest(request);
            return target;
        }
    }

​ 前面的不用解释了吧，主要else中的内容，这是我们3+3+3 中的第二步：清楚旧的request---->构建新的request---->运行新的request。

​ 先是获取request，如果不为null就清除，这里先不管request是什么，因为马上要构建request了，你就知道是什么了。看看buildRequest(…):

//GenericRequestBuilder.class
private Request buildRequest(Target<TranscodeType> target) {
        if (this.priority == null) {
            this.priority = Priority.NORMAL;  //优先权正常
        }
        return this.buildRequestRecursive(target, (ThumbnailRequestCoordinator)null);
    }

再看看buildRequestRecursive(…)方法:

//GenericRequestBuilder.class
private Request buildRequestRecursive(Target<TranscodeType> target, ThumbnailRequestCoordinator parentCoordinator) {
        ThumbnailRequestCoordinator coordinator;
        Request fullRequest;
        Request thumbRequest;
        if (this.thumbnailRequestBuilder != null) {
            if (this.isThumbnailBuilt) {
                throw new IllegalStateException("You cannot use a request as both the main request and a thumbnail, consider using clone() on the request(s) passed to thumbnail()");
            } else {
                if (this.thumbnailRequestBuilder.animationFactory.equals(NoAnimation.getFactory())) {
                    this.thumbnailRequestBuilder.animationFactory = this.animationFactory;
                }

                if (this.thumbnailRequestBuilder.priority == null) {
                    this.thumbnailRequestBuilder.priority = this.getThumbnailPriority();
                }

                if (Util.isValidDimensions(this.overrideWidth, this.overrideHeight) && !Util.isValidDimensions(this.thumbnailRequestBuilder.overrideWidth, this.thumbnailRequestBuilder.overrideHeight)) {
                    this.thumbnailRequestBuilder.override(this.overrideWidth, this.overrideHeight);
                }

                coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
                fullRequest = this.obtainRequest(target, this.sizeMultiplier, this.priority, coordinator);
                this.isThumbnailBuilt = true;
                thumbRequest = this.thumbnailRequestBuilder.buildRequestRecursive(target, coordinator);
                this.isThumbnailBuilt = false;
                coordinator.setRequests(fullRequest, thumbRequest);
                return coordinator;
            }
        } else if (this.thumbSizeMultiplier != null) {
            coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
            fullRequest = this.obtainRequest(target, this.sizeMultiplier, this.priority, coordinator);
            thumbRequest = this.obtainRequest(target, this.thumbSizeMultiplier, this.getThumbnailPriority(), coordinator);
            coordinator.setRequests(fullRequest, thumbRequest);
            return coordinator;
        } else {
            return this.obtainRequest(target, this.sizeMultiplier, this.priority, parentCoordinator);
        }
    }

前面大部分都是压缩和对缩略图的处理，我没研究，举例中是没有压缩的，那么就会走到最后一个else下:

return this.obtainRequest(target, this.sizeMultiplier, this.priority, parentCoordinator);

不得不感慨一句，GenericRequestBulider这个类真是强大，我们已经在里面走了很久了，还没出来。好了，我们看一下obtainRequest(…)吧:

//GenericRequestBuilder.class
private Request obtainRequest(Target<TranscodeType> target, float sizeMultiplier, Priority priority, RequestCoordinator requestCoordinator) {
        return GenericRequest.obtain(this.loadProvider, this.model, this.signature, this.context, priority, target, sizeMultiplier, this.placeholderDrawable, this.placeholderId, this.errorPlaceholder, this.errorId, this.fallbackDrawable, this.fallbackResource, this.requestListener, requestCoordinator, this.glide.getEngine(), this.transformation, this.transcodeClass, this.isCacheable, this.animationFactory, this.overrideWidth, this.overrideHeight, this.diskCacheStrategy);
    }

​ 终于要从GenericRequestBuilder.java 中出来了。先整理一下前面的：我们直接就进入到了GenericRequestBuilder.java 中，在其中主要调用了buildImageViewTarget(…)方法，返回一个GlideDrawableTarget对象，然后找到了第二个"3"的入口：清除request—>构建新的request—>运行新request，最后还有压缩和缩略图处理，如果没有压缩，就到现在的obtainRequest。可以看到调用了GenericRequest.obtain(…)，里面传入了非常多的参数，熟悉的loadProvide、model、context、target、placeholderDrawable、placeholderId、diskCacheStrategy等等，很多，看一下：

//GenericRequest.class
public static <A, T, Z, R> GenericRequest<A, T, Z, R> obtain(LoadProvider<A, T, Z, R> loadProvider, A model, Key signature, Context context, Priority priority, Target<R> target, float sizeMultiplier, Drawable placeholderDrawable, int placeholderResourceId, Drawable errorDrawable, int errorResourceId, Drawable fallbackDrawable, int fallbackResourceId, RequestListener<? super A, R> requestListener, RequestCoordinator requestCoordinator, Engine engine, Transformation<Z> transformation, Class<R> transcodeClass, boolean isMemoryCacheable, GlideAnimationFactory<R> animationFactory, int overrideWidth, int overrideHeight, DiskCacheStrategy diskCacheStrategy) {
        
  GenericRequest<A, T, Z, R> request = (GenericRequest)REQUEST_POOL.poll();
        if (request == null) {
            request = new GenericRequest();
        }
        request.init(loadProvider, model, signature, context, priority, target, sizeMultiplier, placeholderDrawable, placeholderResourceId, errorDrawable, errorResourceId, fallbackDrawable, fallbackResourceId, requestListener, requestCoordinator, engine, transformation, transcodeClass, isMemoryCacheable, animationFactory, overrideWidth, overrideHeight, diskCacheStrategy);
        return request;
    }

主要是从消息池里面poll()一个request对象，没有就new一个，然后调用request的init()方法，因为request就是本身类的对象引用，所以我们直接看init(…)方法，之前传的好多参数全都传入进来了：

//GenericRequest.class
private void init(LoadProvider<A, T, Z, R> loadProvider, A model, Key signature, Context context, Priority priority, Target<R> target, float sizeMultiplier, Drawable placeholderDrawable, int placeholderResourceId, Drawable errorDrawable, int errorResourceId, Drawable fallbackDrawable, int fallbackResourceId, RequestListener<? super A, R> requestListener, RequestCoordinator requestCoordinator, Engine engine, Transformation<Z> transformation, Class<R> transcodeClass, boolean isMemoryCacheable, GlideAnimationFactory<R> animationFactory, int overrideWidth, int overrideHeight, DiskCacheStrategy diskCacheStrategy) {
        this.loadProvider = loadProvider;
        this.model = model;
        //...全是this.xxx = xxx;
        if (model != null) {
            check("ModelLoader", loadProvider.getModelLoader(), "try .using(ModelLoader)");
            check("Transcoder", loadProvider.getTranscoder(), "try .as*(Class).transcode(ResourceTranscoder)");
            check("Transformation", transformation, "try .transform(UnitTransformation.get())");
            if (diskCacheStrategy.cacheSource()) {
                check("SourceEncoder", loadProvider.getSourceEncoder(), "try .sourceEncoder(Encoder) or .diskCacheStrategy(NONE/RESULT)");
            } else {
                check("SourceDecoder", loadProvider.getSourceDecoder(), "try .decoder/.imageDecoder/.videoDecoder(ResourceDecoder) or .diskCacheStrategy(ALL/SOURCE)");
            }

            if (diskCacheStrategy.cacheSource() || diskCacheStrategy.cacheResult()) {
                check("CacheDecoder", loadProvider.getCacheDecoder(), "try .cacheDecoder(ResouceDecoder) or .diskCacheStrategy(NONE)");
            }

            if (diskCacheStrategy.cacheResult()) {
                check("Encoder", loadProvider.getEncoder(), "try .encode(ResourceEncoder) or .diskCacheStrategy(NONE/SOURCE)");
            }
        }
    }

中间省略了好多this.xxx = xxx，也就是属性赋值，往后就是检查一些属性配置；到这里我们"buildRequest"这一步就完事了，最后返回一个Request对象，总的来说就是各种赋值并检测，构建一个Request对象。接下来是"3"步中的最后一步，runRequest(…);先会看一下代码：

//GenericRequestBuilder.class
//..省略
Request request = this.buildRequest(target);
            target.setRequest(request);
            this.lifecycle.addListener(target);
            this.requestTracker.runRequest(request);
            return target;

在run之前，先setRequest一下，在addListener一下，这两部跟我们的run关系不大。我们直接看runRequest(…)吧：

//RequestTracker.class
public void runRequest(Request request) {
        this.requests.add(request);
        if (!this.isPaused) {
            request.begin();
        } else {
            this.pendingRequests.add(request);
        }
    }

如果没有暂停，就使用request.begin()方法，由于我们是GenericRequest ，所以直接看GenericRequest 的begin()方法：

//GenericRequest.class
public void begin() {
        this.startTime = LogTime.getLogTime();
        if (this.model == null) {
            this.onException((Exception)null);
        } else {
            this.status = GenericRequest.Status.WAITING_FOR_SIZE;
            if (Util.isValidDimensions(this.overrideWidth, this.overrideHeight)) {
                this.onSizeReady(this.overrideWidth, this.overrideHeight);
            } else {
                this.target.getSize(this);
            }
            if (!this.isComplete() && !this.isFailed() && this.canNotifyStatusChanged()) {
                this.target.onLoadStarted(this.getPlaceholderDrawable());
            }
           //...
            }
        }
    }

先验证图片的尺寸是否有效，一般是指定了大小，合格了就会this.onSizeReady(…);如果没有指定，经过一番处理还是会调用onSizeReady(…)（感觉这里会出一道面试题，问你怎么计算的），这个方法里面我先大体说一下，从缓存拿数据、从网络拿数据都是这里作为入口，我们先想一下，从缓存读数据和从网络获取数据应该都是异步的，所以我们在获取到图片资源这段时间要干什么呢？没错，就是往下走，会走到this.targetonLoadStarted(…)方法，将placeholder设置的图片拿出来放进去，要是你写，你也会这么写吧！你可以跟一下，很简单，最后会调用ImageViewTarget 的onLoadStarted()方法，看一下：

public void onLoadStarted(Drawable placeholder) {
        ((ImageView)this.view).setImageDrawable(placeholder);
}

哈哈，就是设置等待时的图片，现在我们可以回来看一看this.onSizeReady(…)干嘛了：

//GenericRequest.class
public void onSizeReady(int width, int height) {
      //...log打印
        if (this.status == GenericRequest.Status.WAITING_FOR_SIZE) {
            this.status = GenericRequest.Status.RUNNING;
            width = Math.round(this.sizeMultiplier * (float)width);
            height = Math.round(this.sizeMultiplier * (float)height);
            ModelLoader<A, T> modelLoader = this.loadProvider.getModelLoader();
            DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(this.model, width, height);
            if (dataFetcher == null) {
                this.onException(new Exception("Failed to load model: '" + this.model + "'"));
            } else {
                ResourceTranscoder<Z, R> transcoder = this.loadProvider.getTranscoder();
              //...log打印
                }
                this.loadedFromMemoryCache = true;
                this.loadStatus = this.engine.load(this.signature, width, height, dataFetcher, this.loadProvider, this.transformation, transcoder, this.priority, this.isMemoryCacheable, this.diskCacheStrategy, this);
                this.loadedFromMemoryCache = this.resource != null;
               //...log打印
                }
            }
        }
    }

前面的部分其实都是三大步中load(…)那步涉及的操作，现在把它们取出来，建议自己看看，后面文章还要再讲讲，我们直接看看this.engine.load(…)，之前的操作最后都会集中到这里：

//Engine.class
public <T, Z, R> Engine.LoadStatus load(Key signature, int width, int height, DataFetcher<T> fetcher, DataLoadProvider<T, Z> loadProvider, Transformation<Z> transformation, ResourceTranscoder<Z, R> transcoder, Priority priority, boolean isMemoryCacheable, DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {
        Util.assertMainThread();
        long startTime = LogTime.getLogTime();
        String id = fetcher.getId();
        EngineKey key = this.keyFactory.buildKey(id, signature, width, height, loadProvider.getCacheDecoder(), loadProvider.getSourceDecoder(), transformation, loadProvider.getEncoder(), transcoder, loadProvider.getSourceEncoder());
        EngineResource<?> cached = this.loadFromCache(key, isMemoryCacheable);
        if (cached != null) {
            cb.onResourceReady(cached);
            //...log打印
            return null;
        } else {
            EngineResource<?> active = this.loadFromActiveResources(key, isMemoryCacheable);
            if (active != null) {
                cb.onResourceReady(active);
                //...log打印
                return null;
            } else {
                EngineJob current = (EngineJob)this.jobs.get(key);
                if (current != null) {
                    current.addCallback(cb);
                    //...log打印
                    return new Engine.LoadStatus(cb, current);
                } else {
                    EngineJob engineJob = this.engineJobFactory.build(key, isMemoryCacheable);
                    DecodeJob<T, Z, R> decodeJob = new DecodeJob(key, width, height, fetcher, loadProvider, transformation, transcoder, this.diskCacheProvider, diskCacheStrategy, priority);
                    EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
                    this.jobs.put(key, engineJob);
                    engineJob.addCallback(cb);
                    engineJob.start(runnable);
                    //...log打印
                    return new Engine.LoadStatus(cb, engineJob);
                }
            }
        }
    }

显示检查是否在Main线程，然后是从内存缓存拿数据，loadFromCache和loadFromActiveResources都是从缓存拿数据，只是后者是从活跃缓存区拿数据，这就涉及到Glide的缓存机制了，考虑本文只是流程梳理，就不在多说了，后面会再写一篇文章写的。如果缓存中有数据，就直接callback.onResourceReady(…);callback就是GenericRequest.class，看名字也知道是回调，可以自己去看看。正常缓存是没有的，this.jobs就是一个map，自己去看看，重点是创建了一个Runnable，然后start这个runnable，直接看runnable中的run(…)干了什么:

//EngineRunnable.class
public void run() {
        if (!this.isCancelled) {
            Exception exception = null;
            Resource resource = null;
            try {
                resource = this.decode();
            } catch (Exception var4) {
               //...log打印
                exception = var4;
            }
            if (this.isCancelled) {
                if (resource != null) {
                    resource.recycle();
                }
            } else {
                if (resource == null) {
                    this.onLoadFailed(exception);
                } else {
                    this.onLoadComplete(resource);
                }
            }
        }
    }

上来就decode()，然后就recycle()，解码？回收？看看解码吧，怎么就解码了，解什么码？

//EngineRunnable.class 
private Resource<?> decode() throws Exception {
        return this.isDecodingFromCache() ? this.decodeFromCache() : this.decodeFromSource();
    }

看函数名字，一个从缓存解码，一个从Source解码，缓存就不说了，看看后者吧，后者会调用decodeJob.decodeFromSource()：

//DecodeJob.class
public Resource<Z> decodeFromSource() throws Exception {
        Resource<T> decoded = this.decodeSource();  //包含网络访问
        return this.transformEncodeAndTranscode(decoded);  //数据转换
    }

看注释，直接看网络访问吧：

//DecodeJob.class
private Resource<T> decodeSource() throws Exception {
        Resource decoded = null;
        try {
            long startTime = LogTime.getLogTime();
            A data = this.fetcher.loadData(this.priority); //这是重点
           //...log打印
            if (this.isCancelled) {
                Object var5 = null;
                return (Resource)var5;
            }
            decoded = this.decodeFromSourceData(data);
        } finally {
            this.fetcher.cleanup();
        }
        return decoded;
    }

就是将data进行解码，然后返回解码结果，那么data是怎么来的？答案就在this.fetcher.loadData(…);，进去看看，往回跟，最后发现是ImageVideoModelLoader的loadData(…)：

//ImageVideoModelLoader.class 
public ImageVideoWrapper loadData(Priority priority) throws Exception {
            InputStream is = null;
            if (this.streamFetcher != null) {
                try {
                    is = (InputStream)this.streamFetcher.loadData(priority);
                } catch (Exception var6) {
                    //...log打印
                    }
                    if (this.fileDescriptorFetcher == null) {
                        throw var6;
                    }
                }
            }
            ParcelFileDescriptor fileDescriptor = null;
            if (this.fileDescriptorFetcher != null) {
                try {
                    fileDescriptor = (ParcelFileDescriptor)this.fileDescriptorFetcher.loadData(priority);
                } catch (Exception var5) {
                     //...log打印
                    if (is == null) {
                        throw var5;
                    }
                }
            }
            return new ImageVideoWrapper(is, fileDescriptor);
        }

好像看到了不得了的东西，InputStream ! ! !，赶紧看看streamFetcher.loadData(…);streamFetcer回跟发现是HttpUrlFetcher，这是在load(…)那步中注册的Factory生成的，直接看看其中的loadData(…);,直接调用了loadDataWithRedirects(…):

//HttpUrlFetcher.class
private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl, Map<String, String> headers) throws IOException {
        if (redirects >= 5) {
            throw new IOException("Too many (> 5) redirects!");
        } else {
            try {
                if (lastUrl != null && url.toURI().equals(lastUrl.toURI())) {
                    throw new IOException("In re-direct loop");
                }
            } catch (URISyntaxException var8) {
                ;
            }
            this.urlConnection = this.connectionFactory.build(url);
            Iterator i$ = headers.entrySet().iterator();
            while(i$.hasNext()) {
                Entry<String, String> headerEntry = (Entry)i$.next();
                this.urlConnection.addRequestProperty((String)headerEntry.getKey(), (String)headerEntry.getValue());
            }
            this.urlConnection.setConnectTimeout(2500);
            this.urlConnection.setReadTimeout(2500);
            this.urlConnection.setUseCaches(false);
            this.urlConnection.setDoInput(true);
            this.urlConnection.connect();
            if (this.isCancelled) {
                return null;
            } else {
                int statusCode = this.urlConnection.getResponseCode();
                if (statusCode / 100 == 2) {
                    return this.getStreamForSuccessfulRequest(this.urlConnection);
                } else if (statusCode / 100 == 3) {
                    String redirectUrlString = this.urlConnection.getHeaderField("Location");
                    if (TextUtils.isEmpty(redirectUrlString)) {
                        throw new IOException("Received empty or null redirect url");
                    } else {
                        URL redirectUrl = new URL(url, redirectUrlString);
                        return this.loadDataWithRedirects(redirectUrl, redirects + 1, url, headers);
                    }
                } else if (statusCode == -1) {
                    throw new IOException("Unable to retrieve response code from HttpUrlConnection.");
                } else {
                    throw new IOException("Request failed " + statusCode + ": " + this.urlConnection.getResponseMessage());
                }
            }
        }
    }

这就是网络访问了，使用UrlConnection进行网络访问，返回一个InputStream，回头看，在ImageVideoModelLoader 中将拿到的is，new一个ImageVideoWrapper对象，还要return它，看看它在实例化时做了什么？：

//ImageVideoWrapper.class
public ImageVideoWrapper(InputStream streamData, ParcelFileDescriptor fileDescriptor) {
        this.streamData = streamData;
        this.fileDescriptor = fileDescriptor;
    }

额…好像很简单的赋值，只是将传入的参数进行了一层包装，变为一个实体对象。那我们再往回看，就要回到DecodeJob.class中了，拿到这个data后，进入decodeFromSourceData()，看名字也知道是从数据源中解码:

//DecodeJob.class
private Resource<T> decodeFromSourceData(A data) throws IOException {
        Resource decoded;
        if (this.diskCacheStrategy.cacheSource()) {
            decoded = this.cacheAndDecodeSourceData(data);
        } else {
            long startTime = LogTime.getLogTime();
            decoded = this.loadProvider.getSourceDecoder().decode(data, this.width, this.height);
          //...打印log
        }
        return decoded;
    }

先判断有没有磁盘缓存，有的话就解码并保存到磁盘里，没有的话就通过loadProvider获取解码器解码，先不要管具体是怎么解码的，要不然容易晕，现在只需要知道，拿到数据线包装成一个实体对象，然后解码，然后返回解码结果，即return decoded。现在，将解码结果进行数据转换，即transformEncodeAndTranscode(decoded)方法：

//DecodeJob.class 
private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {
        long startTime = LogTime.getLogTime();
        Resource<T> transformed = this.transform(decoded);
        //...log打印
        this.writeTransformedToCache(transformed);
        startTime = LogTime.getLogTime();
        Resource<Z> result = this.transcode(transformed);
       //...log打印
        return result;
    }

这个方法将转码后的资源放入到缓存中并转码，最后返回转码结果。返回结果会返回到EngineRunnable.class的decode()方法中，而这个方法会直接将结果返回到run()方法里面，然后就会执行到下面的代码：

//EngineRunnable.class
if (resource == null) {
    this.onLoadFailed(exception);
} else {
    this.onLoadComplete(resource);
}

继续看看onLoadComplete(…)方法吧：

//EngineRunnable.java

private void onLoadComplete(Resource resource) {
    manager.onResourceReady(resource);
}

嗯，manager是EngineRunnableManager，这是个接口，实现这个接口的是EngineJob，所以看EngineJob的onResourceReady(…)：

//EngineJob.java

@Override
public void onResourceReady(final Resource<?> resource) {
    this.resource = resource;
    MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
}

发送了一个message消息，看看Handle接受到这个MSG_COMPLETE后会怎么样：

 job.handleResultOnMainThread(); //调用job的方法

job是EngineJob，所以看EnginJob的handleResultOnMainThread(…):

private void handleResultOnMainThread() {
    if (isCancelled) {
        resource.recycle();
        return;
    } else if (cbs.isEmpty()) {
        throw new IllegalStateException("Received a resource without any callbacks to notify");
    }
    //数据要处理一下
    engineResource = engineResourceFactory.build(resource, isCacheable);
    hasResource = true;
    engineResource.acquire();
    listener.onEngineJobComplete(key, engineResource);
    //主要在这里
    for (ResourceCallback cb : cbs) {
        if (!isInIgnoredCallbacks(cb)) {
            engineResource.acquire();
            cb.onResourceReady(engineResource);
        }
    }
    engineResource.release();
}

可以看到循环所有的CallBack，然后调用CallBack的onResourceReady(…);这里的callback之前就已经注册了，所以最后我们调用的是GenericRequest的onResourceReady(…)：

//GenericRequest.java
public void onResourceReady(Resource<?> resource) {
    //...
    Object received = resource.get();
    //...
    onResourceReady(resource, (R) received);
}

看到调用了两个参数的onResourceReady(…)方法，该方法中有一句是核心：

//GenericRequest.java
target.onResourceReady(result, animation);

这个Target就是我们之前说的GlideDrawableImageViewTarget，这里面主要代码如下：

//GlideDrawableImageViewTarget.class
public void onResourceReady(GlideDrawable resource, GlideAnimation<? super GlideDrawable> animation) {
        if (!((GlideDrawable)resource).isAnimated()) {
            float viewRatio = (float)((ImageView)this.view).getWidth() / (float)((ImageView)this.view).getHeight();
            float drawableRatio = (float)((GlideDrawable)resource).getIntrinsicWidth() / (float)((GlideDrawable)resource).getIntrinsicHeight();
            if (Math.abs(viewRatio - 1.0F) <= 0.05F && Math.abs(drawableRatio - 1.0F) <= 0.05F) {
                resource = new SquaringDrawable((GlideDrawable)resource, ((ImageView)this.view).getWidth());
            }
        }
        super.onResourceReady(resource, animation);
        this.resource = (GlideDrawable)resource;
        ((GlideDrawable)resource).setLoopCount(this.maxLoopCount);
        ((GlideDrawable)resource).start();
    }

    protected void setResource(GlideDrawable resource) {
        ((ImageView)this.view).setImageDrawable(resource);
    }

​ 首先是调用了onResourceReady(…);然后调用父类的onResourceReady(…);父类的onResourceReady(…)只是调用了抽象方法setResource(…);这个抽象方法由子类实现，又回到了GlideDrawableImageViewTarget的setResource(…)；方法，随后会setImageDrawable(…);终于结束了…

​ 这篇文章比较长，必须结合代码看，否则跳来跳去就晕了。写到后来我都不想写了，所以文笔加快了许多，导致全文看起来比较不够透彻，本文最大的目的是自我学习总结，其次是给予别人一些帮助，但帮助可能不多，见谅！

​ 了解流程是没有用的，我认为Glide最重要的是缓存的处理 ，这是Glide的核心知识点，了解流程只是让我们知道什么时候用缓存，用了什么缓存等等，真正的缓存机制才是我们要学习的。

​ 如有错误，欢迎指正。