简介
由于在Android项目开发中我们经常会用到图片加载，你会选择什么第三库来加载图片，今天让我们来学习一下Glide图片加载库的源码吧，之前文章有讲解到Glide的简单使用。
简单使用
这里就不说添加依赖那些了，大家可以看官方文档，或者我之前的文章Glide的简单使用，但是版本现在最新的版本是4.8.0。
接下来我们看看Glide是如何加载图片的，如下代码
public class MainActivity extends AppCompatActivity {
ImageView imageView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
imageView = findViewById(R.id.imageView);
Glide.with(this).load("http://goo.gl/gEgYUd").into(imageView);
}
}
我们通过上述代码中得到，Glide加载的使用方式是非常简单的。好了根据这句代码我们进行Glide的源码分析吧。
Glide.with(this).load("http://goo.gl/gEgYUd").into(imageView);
通过上述代码我们知道Glide中的with(this)调用的方法中携带了Activity或者Fragment的上下文对象其作用是：用于绑定该上下文对象的生命周期，如Activity或者Fragment的声明周期。代码如下：共有6个不同参数构造方法，返回静态的RequestManager,用于加载图片。
//contex对象
public static RequestManager with(@NonNull Context context) {
return getRetriever(context).get(context);
}
/**
* Begin a load with Glide that will be tied to the given {@link android.app.Activity}'s lifecycle
* and that uses the given {@link Activity}'s default options.
*
* @param activity The activity to use.
* @return A RequestManager for the given activity that can be used to start a load. 用于启动加载的给定activity上下文的RequestManager
*/
public static RequestManager with(@NonNull Activity activity) {
return getRetriever(activity).get(activity);
}
//FragmentActivity 上下文对象
public static RequestManager with(@NonNull FragmentActivity activity) {
return getRetriever(activity).get(activity);
}
// fragment上下文对象
public static RequestManager with(@NonNull Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}
//V4的fragment对象
public static RequestManager with(@NonNull android.app.Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}
// view对象
public static RequestManager with(@NonNull View view) {
return getRetriever(view.getContext()).get(view);
}
RequestManager是通过RequestManagerRetriever的get() 方法获取，而get() 方法中的参数就是我们上述代码传递过来的上下文对象。
然后getRetriever(Context context)方法返回的对象是RequestManagerRetriever,如下代码所示。
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
// 这里通过方法checkNotNull() 校验携带的上下文是否为null，如果是null将抛出空指针异常
Preconditions.checkNotNull(
context,
"You cannot start a load on a not yet attached View or a Fragment where getActivity() "
+ "returns null (which usually occurs when getActivity() is called before the Fragment "
+ "is attached or after the Fragment is destroyed).");
return Glide.get(context).getRequestManagerRetriever();
}
如果校验上下文对象并无异常，则通过Glide.get(context).getRequestManagerRetriever();返回 RequestManagerRetriever对象。
//这里使用的是双重校验单例方式初始化Glide实例
public static Glide get(@NonNull Context context) {
if (glide == null) {
synchronized (Glide.class) {
if (glide == null) {
//检查并初始化Glide
checkAndInitializeGlide(context);
}
}
}
return glide;
}
在checkAndInitializeGlide(context)方法中的initializeGlide(context,builder)方法进行初始化，实例化唯一的Glide实例(双重校验单例方式获取)。
private static void initializeGlide(@NonNull Context context, @NonNull GlideBuilder builder) {
Context applicationContext = context.getApplicationContext();//获取长连接上下文对象
GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules();//通过注解方式生成GeneratedAppGlideModule
List<com.bumptech.glide.module.GlideModule> manifestModules = Collections.emptyList();
if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
//加载Glide Module
manifestModules = new ManifestParser(applicationContext).parse();
}
if (annotationGeneratedModule != null
&& !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
Set<Class<?>> excludedModuleClasses =
annotationGeneratedModule.getExcludedModuleClasses();
Iterator<com.bumptech.glide.module.GlideModule> iterator = manifestModules.iterator();
//清除已经存在的Glide Module
while (iterator.hasNext()) {
com.bumptech.glide.module.GlideModule current = iterator.next();
if (!excludedModuleClasses.contains(current.getClass())) {
continue;
}
...
//清除
iterator.remove();
}
}
...
}
RequestManagerRetriever.RequestManagerFactory factory =
annotationGeneratedModule != null
? annotationGeneratedModule.getRequestManagerFactory() : null;
//设置Glide Builder 用于建造 Glide
builder.setRequestManagerFactory(factory);
for (com.bumptech.glide.module.GlideModule module : manifestModules) {
module.applyOptions(applicationContext, builder);
}
if (annotationGeneratedModule != null) {
annotationGeneratedModule.applyOptions(applicationContext, builder);
}
//构建Glide 这步非常重要，接下来另一篇文章将重点分析这个模块！！！
Glide glide = builder.build(applicationContext);
for (com.bumptech.glide.module.GlideModule module : manifestModules) {
//注册组件 此方法只调用一次
module.registerComponents(applicationContext, glide, glide.registry);
}
if (annotationGeneratedModule != null) {
annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
}
//上下文注册回调
applicationContext.registerComponentCallbacks(glide);
//设置glide，初始化Glide完成
Glide.glide = glide;
}
有上面我们知道要获取到RequestManager是通过Glide.get(context).getRequestManagerRetriever();调用get()方法。我们来看看getRequestManagerRetriever()方法。
//返回RequestManagerRetrieve对象
public RequestManagerRetriever getRequestManagerRetriever() {
return requestManagerRetriever;
}
现在我得到了RequestManagerRetrieve以后通过RequestManagerRetrieve.get(context)方法就可以获取到我们的RequestManager了。
这里需要注意的是get()方法下面有不同之处。FragmentActivity或者是``
@NonNull
public RequestManager get(@NonNull Context context) {
if (context == null) {
throw new IllegalArgumentException("You cannot start a load on a null Context");
} else if (Util.isOnMainThread() && !(context instanceof Application)) {
if (context instanceof FragmentActivity) {
return get((FragmentActivity) context);
} else if (context instanceof Activity) {
return get((Activity) context);
} else if (context instanceof ContextWrapper) {
return get(((ContextWrapper) context).getBaseContext());
}
}
return getApplicationManager(context);
}
public RequestManager get(FragmentActivity activity) {
if (Util.isOnBackgroundThread()) { ///当前是不是后台线程
return get(activity.getApplicationContext()); //从新调用上边get()方法
} else {
assertNotDestroyed(activity); //通过断言判断是否是已经销毁的上下文对象
FragmentManager fm = activity.getSupportFragmentManager();
return supportFragmentGet(
activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
}
}
supportFragmentGet()方法得到RequestManager对象，当前Activity不能是Finished关闭状态。
// 获取RequestManager 对象
private RequestManager supportFragmentGet(
@NonNull Context context,
@NonNull FragmentManager fm,
@Nullable Fragment parentHint,
boolean isParentVisible) {
//无界面的Fragment,即SupportRequestManagerFragment
SupportRequestManagerFragment current =
getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
// 获取RequestManager
RequestManager requestManager = current.getRequestManager();
if (requestManager == null) {
//获取Glide 实例
Glide glide = Glide.get(context);
//通过RequestManagerFactory构建RequestManager。
//current.getGlideLifecycle()获取生命周期，getRequestManagerTreeNode获取RequestManagerTreeNode
requestManager =
factory.build(
glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
current.setRequestManager(requestManager);
}
return requestManager;
}
到这里我们已经得到了一个无界面的Fragment,即SupportRequestManagerFragment ,让请求和你的activity的生命周期同步。
接下来我们进行到调用load()方法中,看看发生什么情况。我们知道调用load()方法是RequestManager.class，所以我们进入该类发现该类实现了LifecycleListener和ModelTypes<T>接口，而ModelTypes<T>是我们所需的load()方法的接口。
//表示回调是Activity生命周期的三个方法
public interface LifecycleListener {
void onStart();
void onStop();
void onDestroy();
}
而ModelTypes<T>接口刚好是定义了load()方法，如下
interface ModelTypes<T> {
//bitmap参数类型
T load(@Nullable Bitmap bitmap);
//drawable参数类型
T load(@Nullable Drawable drawable);
//string参数类型
T load(@Nullable String string);
//uri参数类型
T load(@Nullable Uri uri);
//file参数类型
T load(@Nullable File file);
//resourceId参数类型
T load(@RawRes @DrawableRes @Nullable Integer resourceId);
//url参数类型
T load(@Nullable URL url);
//byte[]参数类型
T load(@Nullable byte[] model);
//Object 参数类型
T load(@Nullable Object model);
}
当RequestManager调用方法load()代码如下，返回的是RequestBuilder<Drawable>实例，该实例可以进行一些常用的操作，如占位符如：placeholder、error、fallback等方式接下来我们会进行分析该占位符。
//返回一个请求的构建器RequestBuilder<Drawable>
@Override
public RequestBuilder<Drawable> load(@Nullable String string) {
return asDrawable().load(string);
}
我们进入asDrawable()方法看看返回RequestBuilder<Drawable>
//默认情况下，可以返回android.graphics.drawable.BitmapDrawable或GifDrawable，但如果为其他Drawable子类注册了其他解码器，也可以返回任何子类。
public RequestBuilder<Drawable> asDrawable() {
return as(Drawable.class);
}
//用于加载给定资源类的新请求构建器:RequestBuilder<ResourceType>
public <ResourceType> RequestBuilder<ResourceType> as(
@NonNull Class<ResourceType> resourceClass) {
return new RequestBuilder<>(glide, this, resourceClass, context);
}
得到RequestBuilder<ResourceType>以后调用load()，而该类实现的接口是ModelTypes<RequestBuilder<TranscodeType>>，这里区别于RequestManager实现的接口参数ModelTypes<RequestBuilder<Drawable>>，说明在这里已经进行了转码了，从Drawable发生了转码。
@Override
public RequestBuilder<TranscodeType> load(@Nullable String string) {
return loadGeneric(string);
}
@Override
public RequestBuilder<TranscodeType> load(@Nullable Bitmap bitmap) {
return loadGeneric(bitmap)
.apply(diskCacheStrategyOf(DiskCacheStrategy.NONE)); //diskCacheStrategyOf(DiskCacheStrategy.NONE)表示磁盘缓存策略
//apply方法在load(@RawRes @DrawableRes @Nullable Integer resourceId) 、load(@Nullable Drawable drawable)、load(@Nullable Bitmap bitmap)调用
}
//返回当前RequestBuilder<TranscodeType>对象
private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
this.model = model;
isModelSet = true;
return this;
}
接下来我们进入into()方法。
public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
Util.assertMainThread(); // 检查是否为后台线程也就是UI线程，必须在主线程调用Into()方法
Preconditions.checkNotNull(view); //当前view是否为空，是空就报空指针异常。
RequestOptions requestOptions = this.requestOptions;
if (!requestOptions.isTransformationSet()
&& requestOptions.isTransformationAllowed()
&& view.getScaleType() != null) {
//在此方法中克隆，以便如果我们使用此RequestBuilder加载到View中，然后加载到不同的目标中，我们不会保留基于先前View的缩放类型应用的转换。
//获取view的ScaleType
switch (view.getScaleType()) {
case CENTER_CROP:
requestOptions = requestOptions.clone().optionalCenterCrop();
break;
case CENTER_INSIDE:
requestOptions = requestOptions.clone().optionalCenterInside();
break;
case FIT_CENTER:
case FIT_START:
case FIT_END:
requestOptions = requestOptions.clone().optionalFitCenter();
break;
case FIT_XY:
requestOptions = requestOptions.clone().optionalCenterInside();
break;
case CENTER:
case MATRIX:
default:
// Do nothing.
}
}
//调用into()，返回ViewTarget<ImageView, TranscodeType> 对象
return into(
glideContext.buildImageViewTarget(view, transcodeClass),//构建ImageViewTarget,这个类扩展自BaseTarget.class
/*targetListener=*/ null,
requestOptions);
}
在buildImageViewTarget(view, transcodeClass)通过imageViewTargetFactory.buildTarget()工厂方法来返回ViewTarget<ImageView, X>
public <X> ViewTarget<ImageView, X> buildImageViewTarget(
@NonNull ImageView imageView, @NonNull Class<X> transcodeClass) {
return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
}
通过ImageViewTargetFactory工厂方法得到ViewTarget实例，这个过程为后面设置图片加载view.setImageBitmap(resource);使用。
public class ImageViewTargetFactory {
public <Z> ViewTarget<ImageView, Z> buildTarget(@NonNull ImageView view,
@NonNull Class<Z> clazz) {
if (Bitmap.class.equals(clazz)) {
return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget(view); //创建了BitmapImageViewTarget转换为ViewTarget
} else if (Drawable.class.isAssignableFrom(clazz)) {
return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget(view);
} else {
throw new IllegalArgumentException(
"Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
} } }
然后进入上述的into()方法中，该方法构建了Request对象实例过程并进行加载图片。如下代码
//返回ViewTarget<ImageView, TranscodeType>
private <Y extends Target<TranscodeType>> Y into(
@NonNull Y target,
@Nullable RequestListener<TranscodeType> targetListener,
@NonNull RequestOptions options) {
Util.assertMainThread();
Preconditions.checkNotNull(target);
if (!isModelSet) { //是否调用load()方法标志
throw new IllegalArgumentException("You must call #load() before calling #into()");
}
options = options.autoClone(); //设置自动克隆，加锁过程
//构造一个请求Request，通过构建请求递归方式返回Request，调用方法是buildRequestRecursive(), 构建缩略图buildThumbnailRequestRecursive()
//这个方法最终会调用到`SingleRequest.obtain()`并且初始化SingleRequest，而我们想要的Request对象就是SingleRequest返回的
Request request = buildRequest(target, targetListener, options);
Request previous = target.getRequest();
if (request.isEquivalentTo(previous) //判断这个请求和之前的是否是一样的
&& !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {//如果之前已经保存在内存缓存了则跳过内存缓存
request.recycle(); //回收request
//如果请求完成，则再次开始将确保重新传递结果，触发RequestListeners和Targets。 如果请求失败，则再次开始将重新启动请求，
//从而再次完成请求。 如果请求已在运行，我们可以让它继续运行而不会中断。
if (!Preconditions.checkNotNull(previous).isRunning()) {
//使用先前的请求而不是新请求来允许优化，例如跳过设置占位符，跟踪和取消跟踪目标，以及获取在单个请求中完成的视图维度。
previous.begin(); //启动异步加载
}
return target;
}
requestManager.clear(target); //清除target对象
target.setRequest(request); //设置此目标(View)保留的当前请求，不应在Glide外部调用
requestManager.track(target, request); //追踪请求操作
return target;
}
通过上面代码注解我们知道Request初始化过程，并返回了SingleRequest对象。我们进入 requestManager.track(target, request)追踪方法，我要知道target是之前传递过来的View的对象转换而成的，在TargetTracker.class中实现了生命周期LifecycleListener接口，通过弱引用集合WeakHashMap保存了target对象(记得这个对象是View转换而成的)，这里确保了在线程同步状态中执行。然后在requestTracker.runRequest(request);方法中启动了给定了请求request.begin();,在SingleRequest<R>.class中实现了该接口，如下。
@Override
public void begin() {
assertNotCallingCallbacks(); //是否允许回调，如果是true则抛出异常无法在RequestListener或Target回调中启动或清除加载...
stateVerifier.throwIfRecycled();
startTime = LogTime.getLogTime();
if (model == null) {
if (Util.isValidDimensions(overrideWidth, overrideHeight)) { //是否是有效尺寸
width = overrideWidth;
height = overrideHeight;
}
// 如果用户设置了回退可绘制，则仅记录更详细的日志级别，因为回退Drawable表示用户偶尔需要空模型。
int logLevel = getFallbackDrawable() == null ? Log.WARN : Log.DEBUG;
onLoadFailed(new GlideException("Received null model"), logLevel);
return;
}
if (status == Status.RUNNING) {
throw new IllegalArgumentException("Cannot restart a running request");
}
if (status == Status.COMPLETE) { //成功加载媒体
onResourceReady(resource, DataSource.MEMORY_CACHE); // DataSource.MEMORY_CACHE表示从内存缓存中获取数据，该方法表示发布资源，并发布完成并设置为noll ：engine.release(resource); Engine.class负责启动负载并管理活动和缓存资源 这个方法重点
return;
}
status = Status.WAITING_FOR_SIZE; //等待给予目标的回调以确定目标尺寸
if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
onSizeReady(overrideWidth, overrideHeight); //目标图片大小读取，这个方法中开始调用了请求方法，追踪到Engine.load,设置一下缓存策略，并从磁盘，缓存中读取
} else {
target.getSize(this); //获取大小
}
if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
&& canNotifyStatusChanged()) {
target.onLoadStarted(getPlaceholderDrawable()); //加载开始
}
if (IS_VERBOSE_LOGGABLE) {
logV("finished run method in " + LogTime.getElapsedMillis(startTime));
}}
从上述代码中成功加载的状态跟踪方法到这里，我们从开始的加载Resource的对象是ImageView通过转换为最终的target到这里我们将弄明白了这个加载情况，代码如下。
private void onResourceReady(Resource<R> resource, R result, DataSource dataSource) {
boolean isFirstResource = isFirstReadyResource();
status = Status.COMPLETE;
this.resource = resource;
....
isCallingCallbacks = true;
try {
boolean anyListenerHandledUpdatingTarget = false;
if (requestListeners != null) {
for (RequestListener<R> listener : requestListeners) {
anyListenerHandledUpdatingTarget |=
listener.onResourceReady(result, model, target, dataSource, isFirstResource);
}
}
anyListenerHandledUpdatingTarget |=
targetListener != null
&& targetListener.onResourceReady(result, model, target, dataSource, isFirstResource);
if (!anyListenerHandledUpdatingTarget) {
Transition<? super R> animation =
animationFactory.build(dataSource, isFirstResource);
target.onResourceReady(result, animation); //target最后调用加载资源文件读取
}
} finally {
isCallingCallbacks = false;
}
notifyLoadSuccess(); //通知加载成功！
}
我们回再到into()方法中，由于ImageViewTarget<Z>扩展自抽象类ViewTarget<ImageView, Z>而ViewTarget<ImageView, Z>扩展自BaseTarget<Z>该父类实现了Target<Z>接口，所以ImageViewTarget<Z>重写了该方法，而DrawableImageViewTarget.class扩展自ImageViewTarget<Z>,这样最后将会调用setResource()方法
@Override
public void onResourceReady(@NonNull Z resource, @Nullable Transition<? super Z> transition) {
if (transition == null || !transition.transition(resource, this)) {
setResourceInternal(resource);
} else {
maybeUpdateAnimatable(resource);
}}
private void setResourceInternal(@Nullable Z resource) {
setResource(resource);
maybeUpdateAnimatable(resource);
}
public class DrawableImageViewTarget extends ImageViewTarget<Bitmap> {
@Override
protected void setResource(Bitmap resource) {
view.setImageBitmap(resource);
}
}
总结
接下来我们将细分模块进行讲解，本篇只是大致的讲解Glide加载的过程，知道加载完成的步骤，还有某些重要的模块这里没有讲解到。如占位符、缓存、变化等等，下篇见分晓。
推荐
- 我的博客
- 大家可以到我的博客https://eirunye.github.io进行浏览相关文章，大家一起相互探讨技术。
网友评论