//load 过程
--> RequestBuilder load(String string) @RequestManager
--> asDrawable() @RequestManager
--> new RequestBuilder<>(glide, this, resourceClass, context); @RequestManager
--> load(@Nullable String string) @RequestBuilder
--> loadGeneric(string) @RequestBuilder
我们需要关心的 关键点：
总结
子线程，用的是Application 作用域，不会搞空白的 Fragment。主线程，非Application 作用域，通过空白的Fragment 监听。
- 每个Activity 对应一个 Fragment，然后对应一个 RequestManager。
app 包对应 RequestManagerFragment 空白 Fragment
v4 包对应 SupportRequestManagerFragment 空白 Fragment
Application 作用域对应 ApplicationLifecycle
非 Application 作用域对应 ActivityFragmentLifecycle
class ActivityFragmentLifecycle implements Lifecycle {
//管理 LifecycleListener 监听器，一个Activity 对应一个 LifecycleListener
private final Set<LifecycleListener> lifecycleListeners =
Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
private boolean isStarted;
private boolean isDestroyed;
}
Glide架构：（同学们这张图片是网上的图片而已，很模糊，有个大概的认识就行）
一、with 源码：
with时序图：
Glide
- 主要做一些 init 工作，比如缓存，线程池，复用池的构建等等。
RequestManagerRetriever 大管家
- 主要是获得一个 `RequestManager` 请求管理类，然后绑定一个 Fragment 。
SupportRequestManagerFragment :
- 用于管理请求的生命周期。
RequestManager
- 主要用于对请求的管理封装。
-
第一步：调用 with，同学们可以看下 with 这个源码函数，重载有很多：
Glide.java 类
@NonNull
public static RequestManager with(@NonNull Context context) {
return getRetriever(context).get(context);
}
@NonNull
public static RequestManager with(@NonNull Activity activity) {
return getRetriever(activity).get(activity);
}
@NonNull
public static RequestManager with(@NonNull FragmentActivity activity) {
return getRetriever(activity).get(activity);
}
@NonNull
public static RequestManager with(@NonNull Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}
@Deprecated
@NonNull
public static RequestManager with(@NonNull android.app.Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}
@NonNull
public static RequestManager with(@NonNull View view) {
return getRetriever(view.getContext()).get(view);
}
同学们上面其实常用的就 Activity，Fragment, Context 这 3 种形式，下面我们就以 Activity 为主
- 第二步，getRetriever(activity)：
@NonNull
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
Preconditions.checkNotNull(context, "You cannot start a load on a not yet attached View or xxx.");
return get(context).getRequestManagerRetriever();
}
RequestManagerRetriever 是大管家
同学们继续看 get(context)：
public static Glide get(@NonNull Context context) {
if (glide == null) {
GeneratedAppGlideModule annotationGeneratedModule =
getAnnotationGeneratedGlideModules(context.getApplicationContext());
synchronized (Glide.class) {
if (glide == null) {
checkAndInitializeGlide(context, annotationGeneratedModule);
}
}
}
return glide;
}
同学们上面的 Glide get(Context) 是一种双重检测单例模式(DCL)，保证了多线程下安全，仅此而已，非常的简单：
checkAndInitializeGlide(...); 看看做了什么：
private static void checkAndInitializeGlide(
@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
if (isInitializing) {
throw new IllegalStateException(
"You cannot call Glide.get() in registerComponents(),"
+ " use the provided Glide instance instead");
}
//是否初始化标志
isInitializing = true;
//开始进行初始化
initializeGlide(context, generatedAppGlideModule);
isInitializing = false;
}
同学们接着看 initializeGlide(...)
private static void initializeGlide(
@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
//实例化一个 GlideBuilder 在进行初始化
//GlideBuilder 默认的一些配置信息
initializeGlide(context, new GlideBuilder(), generatedAppGlideModule);
}
再接着看initializeGlide
private static void initializeGlide(@NonNull Context context, @NonNull GlideBuilder builder, GeneratedAppGlideModule annotationGeneratedModule) {
//1. 拿到应用级别的上下文，这里可以避免内存泄漏，我们实际开发也可以通过这种形式拿上下文。
Context applicationContext = context.getApplicationContext();
//2. 这里拿到 @GlideModule 标识的注解处理器生成的 GeneratedAppGlideModuleImpl、
//GeneratedAppGlideModuleFactory ...等等。
GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules();
.....
//3. 通过注解生成的代码拿到 RequestManagerFactory
RequestManagerFactory factory = annotationGeneratedModule != null ? annotationGeneratedModule.getRequestManagerFactory() : null;
//4. 将拿到的工厂添加到 GlideBuilder
builder.setRequestManagerFactory(factory);
....
//5. 这里通过 Builder 建造者模式，构建出 Glide 实例对象
Glide glide = builder.build(applicationContext);
//6. 开始注册组件回调
for (com.bumptech.glide.module.GlideModule module : manifestModules) {
try {
module.registerComponents(applicationContext, glide, glide.registry);
} catch (AbstractMethodError e) {
throw new IllegalStateException(
"Attempting to register a Glide v3 module. If you see this, you or one of your"
+ " dependencies may be including Glide v3 even though you're using Glide v4."
+ " You'll need to find and remove (or update) the offending dependency."
+ " The v3 module name is: "
+ module.getClass().getName(),
e);
}
}
if (annotationGeneratedModule != null) {
annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
}
applicationContext.registerComponentCallbacks(glide);
//将构建出来的 glide 赋值给 Glide 的静态变量
Glide.glide = glide;
}
通过上面的注释，相信同学们很容易理解，注意看注释 5 ，这里知道是通过建造者生成的，那么具体内部怎么实现的，接着看：
package com.bumptech.glide;
public final class GlideBuilder {
//管理线程池
private Engine engine;
//对象池(享元模式)，这样做避免重复创建对象，对内存开销有一定效果
private BitmapPool bitmapPool;
private ArrayPool arrayPool;
//GlideExecutor 线程池
private GlideExecutor sourceExecutor;
private GlideExecutor diskCacheExecutor;
//本地磁盘缓存
private DiskCache.Factory diskCacheFactory;
//内存缓存
private MemorySizeCalculator memorySizeCalculator;
private MemoryCache memoryCache;
private ConnectivityMonitorFactory connectivityMonitorFactory;
private int logLevel = Log.INFO;
private RequestOptions defaultRequestOptions = new RequestOptions();
@Nullable
private RequestManagerFactory requestManagerFactory;
private GlideExecutor animationExecutor;
private boolean isActiveResourceRetentionAllowed;
@Nullable
private List<RequestListener<Object>> defaultRequestListeners;
private boolean isLoggingRequestOriginsEnabled;
//都是一些配置信息，用到了 开闭原则。
....
//开始构建，同学们注意：重点留意我写的注释
@NonNull
Glide build(@NonNull Context context) {
//实例化一个网络请求的线程池
if (sourceExecutor == null) {
sourceExecutor = GlideExecutor.newSourceExecutor();
}
//实例化一个本地磁盘缓存的线程池
if (diskCacheExecutor == null) {
diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
}
//实例化一个加载图片动画的一个线程池
if (animationExecutor == null) {
animationExecutor = GlideExecutor.newAnimationExecutor();
}
//实例化一个对图片加载到内存的一个计算
if (memorySizeCalculator == null) {
memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();
}
//实例化一个默认网络连接监控的工厂
if (connectivityMonitorFactory == null) {
connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();
}
//实例化一个 Bitmap 对象池
if (bitmapPool == null) {
int size = memorySizeCalculator.getBitmapPoolSize();
//如果池子里还有可用的，直接加入 最近最少使用的 LruBitmap 容器里
if (size > 0) {
bitmapPool = new LruBitmapPool(size);
} else {
//如果池子已经满了，那么就装在 BitmapPoolAdapter
bitmapPool = new BitmapPoolAdapter();
}
}
//实例化一个数组对象池
if (arrayPool == null) {
arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
}
//资源内存缓存
if (memoryCache == null) {
memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
}
//磁盘缓存的工厂
if (diskCacheFactory == null) {
diskCacheFactory = new InternalCacheDiskCacheFactory(context);
}
//构建执行缓存策略跟线程池的引擎
if (engine == null) {
engine =
new Engine(
memoryCache,
diskCacheFactory,
diskCacheExecutor,
sourceExecutor,
GlideExecutor.newUnlimitedSourceExecutor(),
GlideExecutor.newAnimationExecutor(),
isActiveResourceRetentionAllowed);
}
if (defaultRequestListeners == null) {
defaultRequestListeners = Collections.emptyList();
} else {
defaultRequestListeners = Collections.unmodifiableList(defaultRequestListeners);
}
//实例化一个 RequestManagerRetriever 请求管理类
RequestManagerRetriever requestManagerRetriever =
new RequestManagerRetriever(requestManagerFactory);
//实例化 Glide 的地方
return new Glide(
context,
engine,
memoryCache,
bitmapPool,
arrayPool,
requestManagerRetriever,
connectivityMonitorFactory,
logLevel,
defaultRequestOptions.lock(),
defaultTransitionOptions,
defaultRequestListeners,
isLoggingRequestOriginsEnabled);
}
}
同学们上面的代码中，builder 主要构建线程池、复用池、缓存策略、执行 Engine ，最后构建 Glide 实例，我们看看 Glide 怎么实例化的,主要看对应的构造函数就行了。
Glide(
@NonNull Context context,
@NonNull Engine engine,
@NonNull MemoryCache memoryCache,
@NonNull BitmapPool bitmapPool,
@NonNull ArrayPool arrayPool,
@NonNull RequestManagerRetriever requestManagerRetriever,
@NonNull ConnectivityMonitorFactory connectivityMonitorFactory,
int logLevel,
@NonNull RequestOptions defaultRequestOptions,
@NonNull Map<Class<?>, TransitionOptions<?, ?>> defaultTransitionOptions,
@NonNull List<RequestListener<Object>> defaultRequestListeners,
boolean isLoggingRequestOriginsEnabled) {
//将 Builder 构建的线程池，对象池，缓存池保存到 Glide 中
this.engine = engine;
this.bitmapPool = bitmapPool;
this.arrayPool = arrayPool;
this.memoryCache = memoryCache;
this.requestManagerRetriever = requestManagerRetriever;
this.connectivityMonitorFactory = connectivityMonitorFactory;
//拿到 Glide 对应需要的编解码
DecodeFormat decodeFormat = defaultRequestOptions.getOptions().get(Downsampler.DECODE_FORMAT);
bitmapPreFiller = new BitmapPreFiller(memoryCache, bitmapPool, decodeFormat);
final Resources resources = context.getResources();
registry = new Registry();
registry.register(new DefaultImageHeaderParser());
//忽略一些配置信息
...
//用于显示对应图片的工厂
ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
//构建一个 Glide 专属的 上下文
glideContext =
new GlideContext(
context,
arrayPool,
registry,
imageViewTargetFactory,
defaultRequestOptions,
defaultTransitionOptions,
defaultRequestListeners,
engine,
isLoggingRequestOriginsEnabled,
logLevel);
}
同学们会发现，上面有一个 GlideContentx 这个是什么鬼？ 其实就是 Context一个级别的上下文而已，你看呀
public class GlideContext extends ContextWrapper{ }
同学们到这里我们已经知道了 缓存策略、Glide、GlideContext 怎么构建出来的了，下面我们看怎么拿到 请求管理类 RequestManager
getRetriever(activity).get(activity); 最终是返回 RequestManager：
这里的 get 也有很多重载的函数，同学们只需要看 Activity 参数的重载：
-
RequestManagerRetriever.java类
public class RequestManagerRetriever implements Handler.Callback {
@NonNull
public RequestManager get(@NonNull Context context) {
if (context == null) {
throw new IllegalArgumentException("You cannot start a load on a null Context");
//如果在主线程中并且不为 Application 级别的 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) {
//一直到查找 BaseContext
return get(((ContextWrapper) context).getBaseContext());
}
}
//如果不在主线程中或为 Application 就直接执行
return getApplicationManager(context);
}
private RequestManager getApplicationManager(@NonNull Context context) {
//application 作用域，用 ApplicationLifecycle 监听
if (applicationManager == null) {
synchronized (this) {
if (applicationManager == null) {
Glide glide = Glide.get(context.getApplicationContext());
applicationManager =
factory.build(
glide,
new ApplicationLifecycle(),
new EmptyRequestManagerTreeNode(),
context.getApplicationContext());
}
}
}
@NonNull
public RequestManager get(@NonNull FragmentActivity activity) {
....
}
@NonNull
public RequestManager get(@NonNull Fragment fragment) {
....
}
//通过 Activity 拿到 RequestManager
@SuppressWarnings("deprecation")
@NonNull
public RequestManager get(@NonNull Activity activity) {
//判断当前是否在子线程中请求任务
if (Util.isOnBackgroundThread()) {
//通过 Application 级别的 Context 加载
return get(activity.getApplicationContext());
} else {
//检查 Activity 是否已经销毁
assertNotDestroyed(activity);
//拿到当前 Activity 的 FragmentManager
android.app.FragmentManager fm = activity.getFragmentManager();
//主要是生成一个 Fragment 然后绑定一个请求管理 RequestManager
return fragmentGet(
activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
}
}
}
-
fragmentGet函数实现：
private RequestManager fragmentGet(@NonNull Context context,
@NonNull android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
//1. 在当前的 Acitivty 添加一个 Fragment 用于管理请求的生命周期
RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
//拿到当前请求的管理类
RequestManager requestManager = current.getRequestManager();
//如果不存在，则创建一个请求管理者保持在当前管理生命周期的 Fragment 中，相当于 2 者进行绑定，避免内存泄漏。
if (requestManager == null) {
Glide glide = Glide.get(context);
requestManager =
factory.build(
glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
current.setRequestManager(requestManager);
}
//返回当前请求的管理者
return requestManager;
}
通过上面的代码可知，这里用于 Fragment 管理请求的生命周期，那么我们具体来看看 Fragment 怎么添加到 Activity 中的呢：
private RequestManagerFragment getRequestManagerFragment(
@NonNull final android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
//通过 TAG 拿到已经实例化过的 Fragment ,相当于如果同一个 Activity Glide.with..多次，那么就没有必要创建多个。
RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
//如果在当前 Activity 中没有拿到管理请求生命周期的 Fragment ，那么就从缓存中看有没有
if (current == null) {
current = pendingRequestManagerFragments.get(fm);
//如果缓存也没有得，就直接实例化一个 Fragment
if (current == null) {
current = new RequestManagerFragment();
current.setParentFragmentHint(parentHint);
//如果已经有执行的请求就开始
if (isParentVisible) {
current.getGlideLifecycle().onStart();
}
//添加到 Map 缓存中
pendingRequestManagerFragments.put(fm, current);
//通过当前 Activity 的 FragmentManager 开始提交添加一个 Fragment 容器
fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
//添加到 FragmentManager 成功，发送清理缓存。
handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
}
}
return current;
}
然后又回到fragmentGet方法，因为已经拿到了RequestManagerFragment了： 就可以current.XXXXXX 得到信息了
private RequestManager fragmentGet(@NonNull Context context,
@NonNull android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
...
//如果不存在，则创建一个请求管理者保持在当前管理生命周期的 Fragment 中，相当于 2 者进行绑定，避免内存泄漏。
if (requestManager == null) {
//拿到单例 Glide
Glide glide = Glide.get(context);
//构建请求管理，current.getGlideLifecycle(),就是 ActivityFragmentLifecycle 后面我们会讲到这个类
requestManager =
factory.build(
glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
//将构建出来的请求管理绑定在 Fragment 中。
current.setRequestManager(requestManager);
}
//返回当前请求的管理者
return requestManager;
}
同学们我们知道，with之后，最终返回RequestManager对象， 我们需要对RequestManager对象的构建，有一个来龙去脉的学习：
【同学们注意啊：在Glide4.11 这个最新的版本中，大量使用了 工厂模式：】
// 同学们注意：此工厂就是为了构建出 RequestManager对象
private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() {
@NonNull
@Override
public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
@NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) {
//实例化
return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
}
};
你只要敢 new RequestManager(....); 就会进入 RequestManager的构造方法：
public RequestManager(
@NonNull Glide glide, @NonNull Lifecycle lifecycle,
@NonNull RequestManagerTreeNode treeNode, @NonNull Context context) {
this(
glide,
lifecycle,
treeNode,
new RequestTracker(),
glide.getConnectivityMonitorFactory(),
context);
}
@SuppressWarnings("PMD.ConstructorCallsOverridableMethod")
RequestManager(
Glide glide,
Lifecycle lifecycle,
RequestManagerTreeNode treeNode,
RequestTracker requestTracker,
ConnectivityMonitorFactory factory,
Context context) {
this.glide = glide;
this.lifecycle = lifecycle;
this.treeNode = treeNode;
this.requestTracker = requestTracker;
this.context = context;
connectivityMonitor =
factory.build(
context.getApplicationContext(),
new RequestManagerConnectivityListener(requestTracker));
//这里只要是添加生命周期监听，Fragment 传递过来的
if (Util.isOnBackgroundThread()) {
mainHandler.post(addSelfToLifecycle);
} else {
lifecycle.addListener(this);
}
//添加网络变化的监听
lifecycle.addListener(connectivityMonitor);
defaultRequestListeners =
new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());
setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());
glide.registerRequestManager(this);
}
同学们，到这里请求管理类 RequestManager + Fragment 已经绑定成功了，声明周期监听也设置了，是不是碉堡了：
那他们相互是怎么保证生命周期的传递勒，我们主要看 Fragment 生命周期方法
//这里为什么监控 Fragment 的生命周期勒，其实大家应该也知道 Fragment 是依附在 Activity 的 Activity 的生命周期在 Fragment 中都有，所以监听 Fragment 就行了。
public class RequestManagerFragment extends Fragment {
//相当于生命周期回调
private final ActivityFragmentLifecycle lifecycle;
....
@Override
public void onStart() {
super.onStart();
lifecycle.onStart();
}
@Override
public void onStop() {
super.onStop();
lifecycle.onStop();
}
@Override
public void onDestroy() {
super.onDestroy();
lifecycle.onDestroy();
}
...
}
这里的 lifecycle 是什么，同学们在深入看看去：
class ActivityFragmentLifecycle implements Lifecycle {
private final Set<LifecycleListener> lifecycleListeners =
Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
private boolean isStarted;
private boolean isDestroyed;
@Override
public void addListener(@NonNull LifecycleListener listener) {
lifecycleListeners.add(listener);
if (isDestroyed) {
listener.onDestroy();
} else if (isStarted) {
listener.onStart();
} else {
listener.onStop();
}
}
@Override
public void removeListener(@NonNull LifecycleListener listener) {
lifecycleListeners.remove(listener);
}
void onStart() {
isStarted = true;
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onStart();
}
}
void onStop() {
isStarted = false;
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onStop();
}
}
void onDestroy() {
isDestroyed = true;
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onDestroy();
}
}
}
同学们，这里知道了吧，它实现的是 Glide 中的 Lifecycle 生命周期接口，注册是在刚刚我们讲解 RequestManagerFactory 工厂中实例化的 RequestManager 然后在构造函数中添加了生命周期回调监听，具体来看下。
public class RequestManager implements LifecycleListener,
ModelTypes<RequestBuilder<Drawable>> {
...
@Override
public synchronized void onStart() {
resumeRequests();
targetTracker.onStart();
}
@Override
public synchronized void onStop() {
pauseRequests();
targetTracker.onStop();
}
@Override
public synchronized void onDestroy() {
targetTracker.onDestroy();
for (Target<?> target : targetTracker.getAll()) {
clear(target);
}
targetTracker.clear();
requestTracker.clearRequests();
lifecycle.removeListener(this);
lifecycle.removeListener(connectivityMonitor);
mainHandler.removeCallbacks(addSelfToLifecycle);
glide.unregisterRequestManager(this);
}
同学们：省略代码...
}
同学们注意：这 3 处回调就是 Fragment 传递过来的，用于实时监听请求的状态。
with总结：
根据 with 源码分析，我们知道，Glide.with(Activity) 主要做了 线程池 + 缓存 + 请求管理与生命周期绑定+其它配置初始化的构建，内部的代码其实是很庞大的
二、load 源码
load时序图：
- RequestBuilder : 这是一个通用请求构建类，可以处理通用资源类型的设置选项和启动负载。
同学们：load 函数加载相对于比较简单。我们看下具体代码实现
public class RequestManager implements LifecycleListener,
ModelTypes<RequestBuilder<Drawable>> {
.....
public RequestBuilder<Drawable> load(@Nullable String string) {
//这里调用 Drawable 图片加载请求器为其加载
return asDrawable().load(string);
}
public RequestBuilder<Drawable> asDrawable() {
return as(Drawable.class);
}
@NonNull
@CheckResult
@Override
public RequestBuilder<Drawable> load(@Nullable Uri uri) {
return asDrawable().load(uri);
}
@NonNull
@CheckResult
@Override
public RequestBuilder<Drawable> load(@Nullable File file) {
return asDrawable().load(file);
}
public <ResourceType> RequestBuilder<ResourceType> as(
@NonNull Class<ResourceType> resourceClass) {
return new RequestBuilder<>(glide, this, resourceClass, context);
}
}
同学们，看看load详情：
public class RequestBuilder<TranscodeType> extends BaseRequestOptions<RequestBuilder<TranscodeType>>
implements Cloneable, ModelTypes<RequestBuilder<TranscodeType>> {
public RequestBuilder<TranscodeType> load(@Nullable String string) {
return loadGeneric(string);
}
// 描述加载的数据源-这里可以看做是我们刚刚传递进来的 http://xxxx.png
@Nullable private Object model;
// 描述这个请求是否已经添加了加载的数据源
private boolean isModelSet;
private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
this.model = model;
isModelSet = true;
return this;
}
}
同学们，到这里 RequestBuilder 就构建好了， RequestBuilder构建出来后，都是为了后面的into啊，也意味着，我们目前为止只是摸到Glide的一点点边而已。
